Storage medium for estimating and improving test case generation

ABSTRACT

A technique for estimating and improving the test coverage for large machines, while accumulating minimum information of past test cases (i.e., minimum feedback) is provided. The technique is scalable in the sense that the number of machine instructions needed to measure the test coverage can range from a few instructions to all the instructions. The technique is easily integrated into existing test generation systems and is applicable to both uni- and multi-processing systems.

CROSS REFERENCE TO RELATED APPLICATION

This application is a continuation application of U.S. Ser. No.11/048,965, filed Feb. 2, 2005, the disclosures of which areincorporated by reference herein in their entirety.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates generally to software and hardware test,logic array and hybrid testers, test architecture, test coverage and, inparticular, to test generation tools, test coverage and system leveltesting.

2. Description of Related Art

One of the challenging issues in random testing is measuring the testcoverage of a given test generation tool. In conventional pseudo-randomtest generation methods, test cases are built by using streams ofinstructions and/or input/output commands selected from a groupcontaining instructions and/or commands. Depending on the system undertest (SUT), the number of valid instructions can be on the order ofhundreds or even thousands. The selection criteria for theseinstructions has a direct impact on the achieved test coverage. Thecomplexity of measuring the test coverage increases with the complexityof the SUT. Introducing a new test coverage measurement mechanism intoan existing test generation tool can be time consuming and difficult.

Estimating and improving test case generation is important for gainingconfidence in system tests and to improve test quality. Measuring testcoverage of a given test generation tool can be costly. Tracking eachinstruction and using feedback (between the test case build and resultprediction processes) requires extensive analysis and consumessubstantial test time.

There is a need for a test coverage measuring and enhancing method thatcan be easily incorporated into existing pseudo-random test generationmethods. Also, there is a need for a method that includes biasingschemes used by pseudo-random test case generation methods.

BRIEF SUMMARY OF THE INVENTION

The present invention is directed to methods, systems, and storagemediums for estimating and improving test case generation, which satisfythese needs and others.

A first aspect is a method for estimating and improving test casegeneration. A plurality of instructions to be tested classified intogroups so that the members of each group are instructions that havesimilar architectural behavior. At least one group agent is selected torepresent each group. A checklist is generated for the group. Thechecklist includes test conditions. Test cases are generated for thegroup using the checklist.

A second aspect is a system for estimating and improving test casegeneration, including a storage medium, a bias scheme, and a test casebuild component. The storage medium stores checklist information. Thechecklist information includes test conditions for one group of a numberof groups of instructions. This group is represented by one or moregroup agents, which are one or more of the instructions in the group.The bias scheme component generates test data for the group agent. Thetest data is biased towards improving test coverage for the group. Thetest case build component generates test cases using the checklistinformation and the biased test data.

A third aspect is a storage medium storing instructions for performing amethod for estimating and improving test case generation. A set ofinstructions is classified into groups according to their architecturalbehavior. A dominating pool is determined. The dominating pool is agroup with low test coverage compared to the other groups. A conditionis selected from a checklist associated with the dominating pool. Aninstruction in the dominating pool is randomly selected. Test cases aregenerated for the selected instruction according to the condition.

BRIEF DESCRIPTION OF THE DRAWINGS

These and other features, aspects, and advantages of the presentinvention will become better understood with regard to the followingdescription, appended claims, and accompanying drawings, where:

FIG. 1 is a block diagram of an exemplary embodiment of a pseudo-randomtest generation method without test coverage;

FIG. 2 is a block diagram of an exemplary embodiment of a pseudo-randomtest generation method with test coverage; and

FIG. 3 is a block diagram of exemplary groupings of instructionsgenerated by exemplary embodiments.

DETAILED DESCRIPTION OF THE INVENTION

Exemplary embodiments are directed to methods, systems, and storagemediums for estimating and improving test case generation.

FIG. 1 shows an exemplary embodiment of a pseudo-random test generationmethod without test coverage. This exemplary embodiment includes a biasscheme 100, a test case build process 102, and a simulation process 104.A bias scheme 100 is used to select test instructions and data for testcases. A test case build process 102 generates test cases for systemtests that are executed in the simulation process 104, which predictsresults. The test case build process 102 does not benefit from theeffectiveness of the previous test cases. This exemplary embodiment maybe an existing system that can be modified to include test coverage andmodified to estimate and improve test case generation.

FIG. 2 shows an exemplary embodiment of a pseudo-random test generationmethod with test coverage. This exemplary embodiment also includes abias scheme 202, a test case build process 204, and a simulation process210, which may be the same or similar as those in FIG. 1 or may beimproved. This exemplary embodiment also includes checklist information200, input conditions 206, and output conditions 208.

The checklist information 200 for the group agents and test coveragedata is updated at the beginning and at the end of the simulationprocess 210. In some exemplary embodiments, user input is incorporatedin the checklist information 200. In some exemplary embodiments, thechecklist information 200 stores test coverage data in athree-dimensional matrix.

The bias scheme 202 is useful for selecting test data biased towards aparticular kind of instruction, say memory-to-memory instructions orarithmetic instructions. In an exemplary embodiment, a first instructionis selected randomly using a bias scheme to bias selection towards thedesired kind of instruction. In some exemplary embodiments, the biasscheme 202 uses a history that may include prior test cases and testresults and other information. In some exemplary embodiments, the biasscheme 202 selects test data to improve test coverage using checklistinformation 200.

The test case build process 204 accesses the checklist information 200and determines which groups should be selected more often in a currenttest case. The test case build process 204 may also enhance thegeneration of data for the group having minimum test coverage.

The simulation process 210 receives test cases from the test case buildprocess 204. Before simulation, if the instruction that is beingsimulated is a group agent, test coverage data is collected by updatingthe checklists belonging to this group agent. After simulation, the testresults or output conditions 208 are collected to update the checklistand, therefore, the test coverage data of the group agent. In otherwords, if the instruction that is being simulated is not a group agent,checklists are not updated. However, the instruction's test coverage isestimated or deduced from the test coverage of the group agent(s). Thissaves both test time and effort.

FIG. 3 shows exemplary groupings of instructions generated by exemplaryembodiments. Instructions may be machine language instructions, or anyother kind of high-level or low-level instructions for any kind ofmachine. An instruction set 300, is grouped into a number of groups,{group₁, group₂, group₃, group₄ . . . group_(n-1), group_(n)} 302, eachgroup having group agents {GA_(1,1), . . . GA_(1,M), GA_(2,1) . . .GA_(2,M) . . . GA_(N,1) . . . GA_(N,M)} 304 to represent the group. Eachgroup can be represented by one or more group agents. (Groups are alsoknown as pools.)

In general, for any architecture, there are groups of instructions thatshare common architectural behavior. The reduction of the frequency ofselecting instructions higher test coverage can enhance the testcoverage of instructions with lower test coverage. Test coverage ofparticular instructions that are representative of the group can be usedto estimate and improve system test coverage.

A checklist for an instruction, such as the one shown in Table 1 below,includes input and/or output conditions for test cases to test thatinstruction. By reducing the frequency of selecting an instruction whosechecklist is entirely covered, the test coverage of other instructionsis enhanced. Exemplary embodiments estimate and/or enhance testcoverage.

TABLE 1 Exemplary checklist op1 = op2 |op1| = |op2| and op1 != op2(different signs) op1 = op2 and is infinity or NaN op1 != op2 and eitherone is infinity or NaN op1 is large and op2 is tiny op1 = 0 op1 is closeto MAX op1 is SUBNORMAL

In an exemplary embodiment, instructions are grouped into classes basedon their architecturally defined properties, architectural behavior,implementations, and the like. From each group, a number ofinstructions, which may range from one instruction to the total numberof instructions in the group, are selected as group agents (a/k/a grouprepresentatives). Furthermore, when the number of group agents is large,the group agents can be reduced. In some embodiments, group agents maybe changed dynamically so that each instruction in the group is capableof being a group agent at any given time. Grouping helps alleviate thedifficulties associated with analyzing system test coverage at theinstruction level, especially for large systems.

In this exemplary embodiment, after an instruction is selected as agroup agent, the checklist is created. This checklist includes input andoutput conditions that need to be tested for that instruction. Thechecklist may be obtained from an architectural description of theinstruction. In some embodiments, the instruction is modeled as a finitestate machine to facilitate the creation of the checklist. Employinggroup agents in this way alleviates the difficulty associated withchecking and improving the test coverage of a system with a large numberof instructions.

In this exemplary embodiment, a group having the least test coverage isdetermined. Among the checklists for that group, the criterion with theleast test coverage is identified for test case selection. After thetest case is executed, test coverage of individual instruction groupsand overall system test coverage are provided, such as in a report.

Instructions are selected more often when they are in a group with lowtest coverage. The test coverage is indicated in checklists (seeTable 1) for a group associated with the agent. On the other hand,instructions are selected less often when they are in a group with hightest coverage. When a group agent is executed, the input/outputchecklist for the group agent instruction is updated. As the testcoverage for the group approaches being fully satisfied, the probabilityof allowing instructions in the group to participate in the next streamis reduced. However, the probability of selecting such a group is neverreduced to zero. In other words, none of the groups are deprived frombeing selected in any given test case generation pass.

In this exemplary embodiment, the checklist is updated by a resultprediction process and used subsequently for test case building. Theresult prediction process passes the relative weights that groups arecapable of carrying to the test case build process. Based on theserelative weights, the test case building process selects instructionsfor refined test cases. If a certain group agent's checklist is notfully checked or it takes longer to complete that checklist compared tothe other groups, then there is a need for improvement at the test casebuilding process. In this exemplary embodiment, once an instruction isselected, data is generated to enhance test coverage for the group thatthe instruction belongs to. If a checklist for a certain group agentdoes not become fully checked or takes longer to become completed thanchecklists for other groups, then there is a need for improvement in thetest case building process. In this case, relevant information isprovided to the tester.

In this exemplary embodiment, instructions that are group agents aretreated the same as other instructions. In other words, although groupagents are used to determine the group from which to select the nextinstruction, each group member has an equal chance of being selected.

In some exemplary embodiments, the result prediction process is extendedto multiprocessing systems testing, where interactions among differentprocessors are often emphasized in test cases. For systems with errorreproduction capability, exemplary embodiments attempt not to disturbsuch capability. Exemplary embodiments may be incorporated into existingtest generation tools. Because exemplary embodiments are scalable,incorporation into existing test generation tools is minimized.

An exemplary embodiment creates instruction groups, creates agents foreach group, creates checklist for each group, updates checklists asinstructions are executed, biases selection to groups having the leasttest coverage, and biases input data to enhance covering checklists. Insome embodiments, groups are generated, groups with minimum testcoverage are selected, an area of test emphasis is determined, testcoverage is updated, and test coverage output is displayed. In someembodiments, group agents functionally represent the group, agent andnon-agent instructions are treated equally during test generation,checklists cover hard to test scenarios, and checklists are used ininstruction selection and data biasing.

An exemplary embodiment performs the sample algorithm in Table 2. Thisalgorithm builds test cases using group agents. This algorithm includesdetermining the group with minimum test coverage and determining an areafor enhancement using the checklists of group agents.

TABLE 2 Sample algorithm 1. Classify instructions into groups; 2. Selectgroup agents; 3. while (not EOS) /* end of stream not reached */ 4.  if((do_specials = False) AND (enhance = on)) /*no special cases*/ 5.   if(no d_p) /* no dominating pool */ 6.    select c ε C; /* randomly selectentry from checklist matrix */ 7.     select p: coverage(p) = mincoverage(P); 8.    d_p = p; /* set the pool to dominate for a while */9.   if (d_p) AND (rand(j) = True) /* dominating pool */ 10.     selecti ε d_p; /* randomly select instruction from        dominating pool */11.  if ((i ε d_p) AND (rand(j) = True)) /* instruction belongs to    coverage pools */ 12.   peek coverage; /* check coverage matrices */ 13.  bias input;

In this exemplary embodiment, instructions are classified into groups(a/k/a pools) and group agents are selected to represent each group.During test case generation, while a particular number of instructionsremain to be chosen, the following actions are performed. If there areno special test objectives and test coverage enhancement is the goal,for example, it is checked if there is dominating pool (i.e., a group ofinstructions that should dominate the test case due to the group's lowtest coverage). At the start, there is no dominating pool and all thegroups are the same. As groups are selected, some groups have more orless coverage than other groups. The pool (p) that has group agents withthe minimum test coverage is selected to be the dominating pool. When adominating pool exists, a random number is generated to determinewhether instructions can be randomly selected from the dominating pool.Assuming that the generated random number falls within a predefinedrange, the current instruction for the test case is randomly selectedfrom the dominating pool. Test data for the operands for the currentinstruction is biased to improve the instruction's test coverage. Bypeeking the test coverage achieved by the group agent(s), the input datafor the current instruction is biased towards the least covered cases.The checklists of the group agent(s) are used as a basis for the group'stest coverage.

Preferably, test coverage measurement is minimized in exemplaryembodiments by searching for a group having the least test coverage whenselecting test case. Suppose an instruction set has thirty instructionsthat are classified into three groups, which are represented by threeinstructions (group agents), one instruction per group. For each groupagent, there are ten scenarios to be tested.

Checklists of the group agents can be represented as two-dimensionalarrays. However, to represent the checklist items of the multiplegroups, three-dimensional arrays are needed. For example, array C[i, j,k], where i, j, and k are the group, agent, and checklist item indicesrespectively.

A simple way to determine the group with the least test coverage is tofind the group agents with checklists having the maximum minimums. Thiswould require more than thirty comparisons. To reduce the overheadrelated to the process of finding the group with the least testcoverage, exemplary embodiments attempt to minimize the number ofcomparisons performed. If a group with the least test coverage is to beidentified, two indices of j and k are selected randomly and the group iwhose <j, k> element is the minimum is considered to have the least testcoverage. This makes the number of comparisons just two. In the longrun, each <j, k> will be used as a base for comparison. In general, withthis exemplary embodiment, only n comparisons are performed each time,for a system with n groups, the group with the least test coverage is tobe found.

The checklist, which is updated by the result prediction process, isused during subsequent test case building, in this exemplary embodiment.Updating the checklist does not require analysis of the paths takenduring the result prediction process. Instead, the checklist is updatedby examining the inputs and outputs of individual group agents. Theinformation for an individual group that is passed by the resultprediction process to the test case build process is a weight that thatindividual group can carry. Based upon the weights for the groups, thetest case build process selects instructions for refined test cases.

In this exemplary embodiment, the instructions in groups that are markedfor agents and non-agents are treated alike. In other words, althoughgroup agents are used to determine the group from which the nextinstruction is selected, the group members have equal chances of beingselected. The group (or set of instructions whose agents have theminimum test coverage are labeled as a dominating pool when its membersare selected for a certain number of consecutive times.

Once an instruction that belongs to a group that has less test coverageis selected, the exemplary embodiment attempts to generate data for theinstruction that would enhance test coverage for the group. For example,suppose that an add instruction is chosen to represent a group. Based onthe test coverage achieved by the add instruction, it is determined thatthe group represented by the add instruction has the minimum testcoverage. The checklist for the add instruction indicates that a testcase having operands of the same magnitude but different signs has notbeen generated yet. In this example, instructions from the grouprepresented by the add instruction are selected more often than the restof the instructions. Furthermore, test cases having operands of the samemagnitude but different signs are also generated.

Suppose after a long period of testing, a checklist for a particulargroup agent is not fully checked or the checklist for this particulargroup takes longer to be completed compared to the other groups. Thismay be caused by weaknesses in the test case build process and can serveas an indication that the test case build process needs improvement. Inthis case where the checklist for a particular group agent is not fullychecked, relevant information is presented to the tester.

Consider two IBM™ ESAME groups of instructions, multiply un-normalized(MU) and multiply and add un-normalized (MAU). These two groups includetwelve instructions, each group having similar architected behaviors.There are six instructions in the MU group and six instructions in theMAU group. Each of the six MU instructions takes two hexadecimalfloating point operands, multiplies them, and places at least a portionof the un-normalized result in floating point registers. Each of the sixMAU instructions multiples two hexadecimal operands and adds theun-normalized result to the contents of the first operand. The MAUinstructions place at least a portion of the result in the firstoperand. Some differences between the MU and the MAU instructionsinclude: operand lengths (64 or 128 bits), operand sources (floatingpoint registers or a combination of floating point registers andmemory), and whether at least a portion of the result is placed in thefirst operand.

In this exemplary embodiment, the MU and MAU instructions are a group,because the architectural behavior (i.e., definitions, andimplementations) of these instructions is similar. Two of the MU and MAUinstructions are selected as group agents, in this exemplary embodiment.One group agent is selected from instructions with 128 bit operands.These operands come from a combination of floating point registers andmemory and at least a portion of the instruction results is placed inthe first operand. The other group agent is selected to be aninstruction that has 64 bit operands that come from floating pointregisters and the whole result in placed in the first operand.

In this exemplary embodiment, a goal is to assure that theseinstructions are well tested while minimizing the overhead of the testcoverage. Since the group agents may be dynamically changed, each of theMU and MAU instructions could be a group agent at any given time.

In this exemplary embodiment, the checklist for a group agent depends onthe test cases that the test designer needs to accomplish. Suppose thechecklist includes the basic features that need to be covered for thegroup agent. Table 3 shows an exemplary checklist for the MU and MAUagents.

Table 3. Exemplary checklist for MU and MAU agents.

1. Operand one is equal to operand two.

2. Operand one and operand two have the same magnitude but differentsigns.

3. Operand one's exponent is or is close to the maximum value, whileoperand two's exponent is or is close to the minimum value.

4. Both operand one's exponent and operand two's exponent are or areclose to the maximum value.

5. Operand one's exponent is less than the maximum value but the sum ofthe exponents is greater than the maximum value.

6. Either or both operands are zero.

7. Both operands are positive and non-zero, but the result is zero.

8. Specification exceptions, if applicable.

9. Protection exceptions, if applicable.

Some exemplary embodiments are extended to multiprocessing systemstesting, where interactions among different processors are emphasized.Some exemplary embodiments attempt not to disturb systems with errorreproduction capability. Exemplary embodiments may be incorporated intoexisting test generation tools. Because exemplary embodiments arescalable, the effort of incorporation into test generation tools islessened.

Exemplary embodiments have many advantages. Exemplary embodimentsclassify instructions into groups and create group agents. There is afocus on group agencies, rather than the entire instruction group.Exemplary embodiments are scalable so that the number of group agentscan be increased or decreased easily. The usage of test coverageachieved by group agents in the process of building new test cases isimproved for both instruction selection and data generation time.Exemplary embodiments use checklists from the group agents as testcoverage estimation and enhancement. Exemplary embodiments may be usedfor test coverage estimating and/or enhancing a test engine. Exemplaryembodiments may be easily incorporated into existing test generationtools. Exemplary embodiments maintain error reproduction capabilities.

Additional advantages include estimating test coverage of randomlygenerated test cases, enhancing test coverage, scalability andadaptability of test coverage, minimizing test coverage overhead, andmaintaining error reproducibility, while keeping minimum information,among others.

As described above, the embodiments of the invention may be embodied inthe form of computer implemented processes and apparatuses forpracticing those processes. Embodiments of the invention may also beembodied in the form of computer program code containing instructionsembodied in tangible media, such as floppy diskettes, CD-ROMs, harddrives, or any other computer-readable storage medium, wherein, when thecomputer program code is loaded into and executed by a computer, thecomputer becomes an apparatus for practicing the invention. Whenimplemented on a general-purpose microprocessor, the computer programcode segments configure the microprocessor to create specific logiccircuits.

While the invention has been described with reference to exemplaryembodiments, it will be understood by those skilled in the art thatvarious changes may be made and equivalents may be substituted forelements thereof without departing from the scope of the invention. Inaddition, future improvements or changes to standards may be used withminor adaptations of various embodiments of the present invention.Furthermore, various components may be implemented in hardware,software, or firmware or any combination thereof. Finally, manymodifications may be made to adapt a particular situation or material tothe teachings of the invention without departing from the essentialscope thereof. Therefore, it is intended that the invention is not to belimited to the particular embodiment disclosed as the best or only modecontemplated for carrying out this invention, but that the inventionwill include all embodiments falling within the scope of the appendedclaims. Moreover, the use of the terms first, second, etc. do not denoteany order or importance, but rather the terms first, second, etc. areused to distinguish one element from another. Furthermore, the use ofthe terms a, an, etc. do not denote a limitation of quantity, but ratherdenote the presence of at least one of the referenced item.

1. A computer program product, comprising: a computer storage mediumincluding computer readable computer program code for estimating andimproving test case generation; and instructions for causing a computerto implement a method, the method further comprising: classifying aplurality of instructions into a plurality of groups according toarchitectural behavior; determining a dominating pool from the groups,the dominating pool being a group having relatively low test coverage incomparison to the other groups; selecting a condition from a checklistassociated with the dominating pool; randomly selecting an instructionin the dominating pool; and generating test cases for the selectedinstruction according to the condition.
 2. The computer program productof claim 1, wherein the method further comprises: biasing test data forthe test cases to improve test coverage.
 3. The computer program productof claim 1, wherein the method further comprises: selecting at least onegroup agent for each group; wherein the selected instruction is thegroup agent for the dominating pool.
 4. The computer program product ofclaim 3, wherein the method further comprises: estimating test coveragefor the group with test coverage for the group agent.